<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>对象创建</title>
</head>
<body>
    
</body>
</html>
<script>
    //使用Object.create创建一个对象的时候使用现在对象作为新创建对象的原型
    // let user = {
    //     show(){
    //         return this.name;
    //     }
    // };

    // let xjs = {};
    //给对象设置原型
    // Object.setPrototypeOf(xjs,user);
    // //获取对象所属的原型
    // console.log(Object.getPrototypeOf(xjs));
    // console.log(xjs);

    // //强制设置时候使用第二个参数的时候设置新属性的对象
    // let hd = Object.create(user,{
    //     name : {
    //         value : "后盾人"
    //     }
    // });
    // hd.name = "向军";
    // console.log(hd);

    // let xj = {};
    // // console.log(xj.__proto__);
    // xj.__proto__ = "向军";
    // console.log(xj);

    //此对象没有原型  没有原型的 给  __proto__进行赋值的时候   就相当于正常的赋值
    // let hd = Object.create(null);
    // hd.__proto__ = "向军";
    // console.log(hd)

    //记得一点  对象里面的__proto__不是属性   它是getter和setter的实现
    //通过gttter和setter实现的方法  会把原本的设置对象覆盖掉 拦截掉

    //__proto__原理
    // let hd = {
    //     action : {},
    //     get proto(){
    //         return this.action;
    //     },
    //     set proto(obj){
    //         if(obj instanceof Object){
    //             this.action = obj;
    //         }
    //     }
    // };

    // //改变对象的原型
    // hd.proto = {view:function(){}};
    // hd.proto = 'abc';
    // console.log(hd.proto);

        
    //可以通过改变对象的__proro__原型对象来实现原型继承  继承可以实现多层
    //对象的继承是原型的继承  而不是直接改变原型    一层一层的继承显示
    // let hd = {
    //     name : "后盾人"
    // };

    // let houdunren = {
    //     show(){
    //         return this.name;
    //     }
    // };

    // let xj = {
    //     handle(){
    //         return `用户:${this.name}`;
    //     }
    // };
    // houdunren.__proto__ = xj;
    // hd.__proto__ = houdunren;
    // console.log(hd.show());
    // console.log(hd.handle());

    /*

    //构造函数直接修改对象原型不叫继承 
    function User(name){
        this.name = name;
    }

    function Admin(name){
        this.name = name;
    }

    Admin.prototype.showAdmin = function(){
        return this.name;
    }

    User.prototype.show = function(){
        return this.name;
    }

    //User想要使用showAdmin方法   那么就可以直接修改User的原型对象
    //使用这种方法在修改原型的时候   会吧原来的原型完全替换掉  虽然可以使用现在想要的方法   但是  以前对象里面的方法将不能使用
    //便于理解的例子   当你在继承家产的时候  不是继承之后你自己的财产也没了    而是自己的要在 继承的也要在     
    //所以这种方式明显是不恰当的
    User.prototype = Admin.prototype;

    //每次实例化的时候都会给这个新的对象一个show方法，这对资源来说是一个很大的浪费
    //所以一般会使用原型的方法
    let u = new User('张三');
    let i = new User('李四');
    console.log(u)
    console.log(i);
    console.log(u.__proto__ == i.__proto__);

    console.log(Object.getPrototypeOf(u));

    */



/*
    //构造函数的__proto__使用
    function User(name,age){
        this.name = name;
        this.age = age;
    }

    //给对象的原型添加方法
    User.prototype.show = function(){
        return `姓名:${this.name},年龄:${this.age}`;
    }

    let lisi = new User('李四',12);
    let xiaoming = new User('小明',20);
    console.log(lisi.__proto__ == xiaoming.__proto__);
*/


//可以使用__proto__或者使用  Object.setprototypeOf 设置对象原型，使用Object.getProtoeyOf获取对象原型
// function Person(){
//     this.getName = function(){
//         return this.name;
//     }
// }


// function User(name,age){
//     this.name = name;
//     this.age = age;
//     this.showAge = function(){
//         return this.age;
//     }
// }
// Object.setPrototypeOf(User,Person);
// let lisi = new User('李四',15);
// // Object.setPrototypeOf(lisi,new Person());
// // console.log(lisi.showAge());
// console.log(lisi)


//给对象设置属性 只是修改对象本身的属性  不会修改原型
//使用hasOwnproperty 检测当前对象是不是有某个属性
// function User(){}

// const lisi = new User();

// const wangwu = new User();

// lisi.name = '小明';

// console.log(lisi.name);
// // console.log(lisi.hasOwnProperty('name'));

// //修改原型属性之后
// //当修改原型属性之后   当前对象有name的话 还是使用当前的name  当前对象里面如果没有name的话，将再原型中进行查找
// lisi.__proto__.name = '张三';
// console.log(wangwu.name);

// //删除对象属性之后
// delete lisi.name;
// console.log(lisi)
// //只能检测当前对象是否存在某个属性
// console.log(lisi.hasOwnProperty('name'));
// console.log(lisi.name)




//使用in会检测原型与对象
// function User(){}
// User.prototype.name = '后盾热';
// const lisi = new User();
// //in会检测属性是否再原型中
// console.log('name' in lisi);
// //hasOwnProerty检测对象属性
// console.log(lisi.hasOwnProperty("name"));










</script>